// 反转字符串

class Solution {
public:
    void reverseString(vector<char>& s) 
    {
        int left = 0, right = s.size() - 1;

        while(left < right)
        {
            char temp = s[left];
            s[left] = s[right];
            s[right] = temp;

            left++;
            right--;
        }
    }
};


#include <iostream>
#include <cstring>
#include <cassert>
#include <string>

using namespace std;


// class string
// {
// private:
//     char* _str;

// public:
//     string(const char* str = "")
//     {
//         if(str == nullptr)
//         {
//             assert(str);
//             return;
//         }

//         _str = new char[strlen(str) + 1];
//         strcpy(_str, str);
//     }

//     string(const string& s)
//         : _str(new char[strlen(s._str) + 1])
//     {
//         strcpy(_str, s._str);
//     }

//     string& operator=(const string& s)
//     {
//         if(this != &s)
//         {
//             char* tmp = new char[strlen(s._str) + 1];
//             strcpy(tmp, s._str);
//             delete[] _str;
//             _str = tmp;
//         }

//         return *this;
//     }

//     ~string()
//     {
//         if(_str)
//         {
//             delete[] _str;
//             _str = nullptr;
//         }
//     }

// };


// class string
// {
// private:
//     char* _str;

// public:
//     string(const char* str = "")
//     {
//         if(nullptr == str)
//         {
//             assert(str);
//             return;
//         }

//         _str = new char[strlen(_str) + 1];
//         strcpy(_str, str);
//     }

//     string(const string& s)
//         : _str(new char[strlen(s._str) + 1])
//     {
//         strcpy(_str, s._str);
//     }

//     string& operator=(const string& s)
//     {
//         if(this != &s)
//         {
//             char* tmp = new char[strlen(s._str) + 1];
//             strcpy(tmp, s._str);
//             delete[] _str;
//             _str = tmp;
//         }

//         return *this;
//     }

//     ~string()
//     {
//         if(_str)
//         {
//             delete[] _str;
//             _str = nullptr;
//         }
//     }
// };


// class string
// {
// private:
//     char* _str;

// public:
//     string(const char* str = "")
//     {
//         if(nullptr == str)
//         {
//             assert(str);
//             return;
//         }

//         _str = new char[strlen(str) + 1];
//         strcpy(_str, str);
//     }

//     // string(const string& s)
//     //     : _str(new char[strlen(s._str) + 1])
//     // {
//     //     strcpy(_str, s._str);
//     // }

//     void swap(string& s)
//     {
//         std::swap(_str, s._str);
//     }

//     string(const string& s)
//     {
//         string tmp(s._str);
//         swap(tmp);
//     }

//     // string& operator=(const string& s)
//     // {
//     //     if(this != &s)
//     //     {
//     //         char* tmp = new char[strlen(s._str) + 1];
//     //         strcpy(tmp, s._str);
//     //         delete[] _str;
//     //         _str = tmp;
//     //     }

//     //     return *this;
//     // }

//     string& operator=(string s)
//     {
//         swap(s);
//         return *this;    
//     }

//     ~string()
//     {
//         if(_str)
//         {
//             delete[] _str;
//             _str = nullptr;
//         }
//     }
// };


// class string
// {
// private:
//     char* _str;

// public:
//     string(const char* str = "")
//     {
//         if(nullptr == str)
//         {
//             assert(str);
//             return;
//         }

//         _str = new char[strlen(str) + 1];
//         strcpy(_str, str);
//     }

//     // string(const string& s)
//     //     : _str(new char[strlen(s._str) + 1])
//     // {
//     //     strcpy(_str, s._str);
//     // }

//     void swap(string& s)
//     {
//         std::swap(_str, s._str);
//     }

//     string(const string& s)
//     {
//         string tmp(s._str);
//         swap(tmp);
//     }

//     // string& operator=(const string& s)
//     // {
//     //     if(this != &s)
//     //     {
//     //         char* tmp = new char[strlen(s._str) + 1];
//     //         strcpy(tmp, s._str);
//     //         delete[] _str;
//     //         _str = tmp;
//     //     }

//     //     return *this;
//     // }

//     string& operator=(string s)
//     {
//         swap(s);
//         return *this;
//     }

//     ~string()
//     {
//         if(_str)
//         {
//             delete[] _str;
//             _str =  nullptr;
//         }
//     }

// };


// class string
// {
// private:
//     char* _str;

// public:
//     string(const char* str = "")
//     {
//         if(nullptr == str)
//         {
//             assert(str);
//             return;
//         }

//         _str = new char[strlen(str) + 1];
//         strcpy(_str, str);
//     }

//     // string(const string& s)
//     //     : _str(new char[strlen(s._str) + 1])
//     // {
//     //     strcpy(_str, s._str);
//     // }

//     void swap(string& s)
//     {
//         std::swap(_str, s._str);
//     }

//     string(const string& s)
//     {
//         string tmp(s._str);
//         swap(tmp);
//     }

//     // string& operator=(const string& s)
//     // {
//     //     if(this != &s)
//     //     {
//     //         char* tmp = new char[strlen(s._str) + 1];
//     //         strcpy(tmp, s._str);
//     //         delete[] _str;
//     //         _str = nullptr;
//     //     }

//     //     return *this;
//     // }

//     string& operator=(string s)
//     {
//         swap(s);
//         return *this;
//     }

//     ~string()
//     {
//         if(_str)
//         {
//             delete[] _str;
//             _str = nullptr;
//         }
//     }
// };


// class string
// {
// private:
//     char* _str;

// public:
//     string(const char* str = "")
//     {
//         if(nullptr == str)
//         {
//             assert(str);
//             return;
//         }

//         _str = new char[strlen(str) + 1];
//         strcpy(_str, str);
//     }

//     // string(const string& s)
//     //     : _str(new char[strlen(s._str) + 1])
//     // {
//     //     strcpy(_str, s._str);
//     // }


//     void swap(string& s)
//     {
//         std::swap(_str, s._str);
//     }

//     string(const string& s)
//     {
//         string tmp(s._str);
//         swap(tmp);
//     }

//     // string& operator=(const string& s)
//     // {
//     //     if(this != &s)
//     //     {
//     //         char* tmp = new char[strlen(s._str) + 1];
//     //         strcpy(tmp, s._str);
//     //         delete[] _str;
//     //         _str = tmp;
//     //     }

//     //     return *this;
//     // }

//     string& operator=(string s)
//     {
//         swap(s);
//         return *this;
//     }

//     ~string()
//     {
//         if(_str)
//         {
//             delete[] _str;
//             _str = nullptr;
//         }
//     }

// };


// class string
// {
// private:
//     char* _str;

// public:
//     string(const char* str = "")
//     {
//         if(nullptr == str)
//         {
//             assert(str);
//             return;
//         }

//         _str = new char[strlen(str) + 1];
//         strcpy(_str, str);
//     }

//     // string(const string& s)
//     //     : _str(new char[strlen(s._str) + 1])
//     // {
//     //     strcpy(_str, s._str);
//     // }

//     void swap(string& s)
//     {
//         std::swap(_str, s._str);
//     }

//     string(const string& s)
//     {
//         string tmp(s._str);
//         swap(tmp);
//     }

//     // string& operator=(const string& s)
//     // {
//     //     if(this != &s)
//     //     {
//     //         char* tmp = new char[strlen(s._str) + 1];
//     //         strcpy(tmp, s._str);
//     //         delete[] _str;
//     //         _str = tmp;
//     //     }

//     //     return *this;
//     // }

//     string& operator=(string s)
//     {
//         swap(s);
//         return *this;
//     }

//     ~string()
//     {
//         if(_str)
//         {
//             delete[] _str;
//             _str = nullptr;
//         }
//     }
// };

// class string
// {
// private:
//     char* _str;

// public:
//     string(const char* str = "")
//     {
//         if(nullptr == str)
//         {
//             assert(str);
//             return;
//         }

//         _str = new char[strlen(str) + 1];
//         strcpy(_str, str);
//     }

//     // string(const string& s)
//     //     : _str(new char[strlen(s._str) + 1])
//     // {
//     //     strcpy(_str, s._str);
//     // }

//     void swap(string& s)
//     {
//         std::swap(_str, s._str);
//     }

//     string(const string& s)
//     {
//         string tmp(s._str);
//         swap(tmp);
//     }

//     // string& operator=(const string& s)
//     // {
//     //     if(this != &s)
//     //     {
//     //         char* tmp = new char[strlen(s._str) + 1];
//     //         strcpy(tmp, s._str);
//     //         delete[] _str;
//     //         _str = tmp;
//     //     }

//     //     return *this;
//     // }

//     string& operator=(string s)
//     {
//         swap(s);
//         return *this;
//     }

//     ~string()
//     {
//         if(_str)
//         {
//             delete[] _str;
//             _str = nullptr;
//         }

//     }
// };


// class string
// {
// private:
//     char* _str;

// public:
//     string(const char* str = "")
//     {
//         if(nullptr == str)
//         {
//             assert(str);
//             return;
//         }

//         _str = new char[strlen(str) + 1];
//         strcpy(_str, str);
//     }

//     // string(const string& s)
//     //     : _str(new char[strlen(s._str) + 1])
//     // {
//     //     strcpy(_str, s._str);
//     // }

//     void swap(string& s)
//     {
//         std::swap(_str, s._str);
//     }

//     string(const string& s)
//     {
//         string tmp(s._str);
//         swap(tmp);
//     }

//     // string& operator=(const string& s)
//     // {
//     //     if(this != &s)
//     //     {
//     //         char* tmp = new char[strlen(s._str) + 1];
//     //         strcpy(tmp, s._str);
//     //         delete[] _str;
//     //         _str = tmp;
//     //     }

//     //     return *this;
//     // }

//     string operator=(string s)
//     {
//         swap(s);
//         return *this;
//     }

//     ~string()
//     {
//         if(_str)
//         {
//             delete[] _str;
//             _str = nullptr;
//         }
//     }
// };


// class string
// {
// private:
//     char* _str;

// public:
//     string(const char* str = "")
//     {
//         if(nullptr == str)
//         {
//             assert(str);
//             return;
//         }

//         _str = new char[strlen(str) + 1];
//         strcpy(_str, str);
//     }

//     // string(const string& s)
//     //     : _str(new char[strlen(s._str) + 1])
//     // {
//     //     strcpy(_str, s._str);
//     // }

//     void swap(string& s)
//     {
//         std::swap(_str, s._str);
//     }

//     string(const string& s)
//     {
//         string tmp(s._str);
//         swap(tmp);
//     }

//     // string& operator=(const string& s)
//     // {
//     //     if(this != &s)
//     //     {
//     //         char* tmp = new char[strlen(s._str) + 1];
//     //         strcpy(tmp, s._str);
//     //         delete[] _str;
//     //         _str = tmp;
//     //     }

//     //     return *this;
//     // }

//     string& operator=(string s)
//     {
//         swap(s);
//         return *this;
//     }

//     ~string()
//     {
//         if(_str)
//         {
//             delete[] _str;
//             _str = nullptr;
//         }
//     }
// };

// class string
// {
// private:
//     char* _str;

// public:
//     string(const char* str = "")
//     {
//         if(str == nullptr)
//         {
//             assert(str);
//             return;
//         }

//         _str = new char[strlen(str) + 1];
//         strcpy(_str, str);
//     }

//     // string(const string& s)
//     //     : _str(new char[strlen(s._str) + 1])
//     // {
//     //     strcpy(_str, s._str);
//     // }

//     void swap(string& s)
//     {
//         std::swap(_str, s._str);
//     }

//     string(const string& s)
//     {
//         string tmp(s._str);
//         swap(tmp);
//     }

//     // string& operator=(const string& s)
//     // {
//     //     if(this != &s)
//     //     {
//     //         char* tmp = new char[strlen(s._str) + 1];
//     //         strcpy(tmp, s._str);
//     //         delete[] _str;
//     //         _str = tmp;
//     //     }

//     //     return *this;
//     // }

//     string& operator=(string s)
//     {
//         swap(s);
//         return *this;
//     }
// };

// class string
// {
// private: 
//     char* _str;

// public:
//     string(const char* str = "")
//     {
//         if(nullptr == str)
//         {
//             assert(str);
//             return;
//         }

//         _str = new char[strlen(str) + 1];
//         strcpy(_str, str);
//     }

//     // string(const string& s)
//     //     : _str(new char[strlen(s._str) + 1])
//     // {
//     //     strcpy(_str, s._str);
//     // }

//     void swap(string& s)
//     {
//         std::swap(_str, s._str);
//     }

//     string(const string& s)
//     {
//         string tmp(s._str);
//         swap(tmp);
//     }

//     // string& operator=(const string& s)
//     // {
//     //     if(this != &s)
//     //     {
//     //         char* tmp = new char[strlen(s._str) + 1];
//     //         strcpy(tmp, s._str);
//     //         delete[] _str;
//     //         _str = tmp;
//     //     }

//     //     return *this;
//     // }

//     string& operator=(string s)
//     {
//         swap(s);
//         return *this;
//     }
// };


// class string
// {
// private:
//     char* _str;

// public:
//     string(const char* str = "")
//     {
//         if(nullptr == str)
//         {
//             assert(str);
//             return;
//         }

//         _str = new char[strlen(str) + 1];
//         strcpy(_str, str);
//     }

//     // string(const string& s)
//     //     : _str(new char[strlen(s._str) + 1])
//     // {
//     //     strcpy(_str, s._str);
//     // }

//     void swap(string& s)
//     {
//         std::swap(_str, s._str);
//     }

//     string(const string& s)
//     {
//         string tmp(s._str);
//         swap(tmp);
//     }

//     // string& operator=(const string& s)
//     // {
//     //     if(this != &s)
//     //     {
//     //         char* tmp = new char[strlen(s._str) + 1];
//     //         strcpy(tmp, s._str);
//     //         delete[] _str;
//     //         _str = tmp;
//     //     }

//     //     return *this;
//     // }

//     string& operator=(string s)
//     {
//         swap(s);
//         return *this;
//     }

//     ~string()
//     {
//         if(_str)
//         {
//             delete[] _str;
//             _str = nullptr;
//         }
//     }


// };


// class string
// {
// private:
//     char* _str;

// public:
//     string(const char* str = "")
//     {
//         if(nullptr == str)
//         {
//             assert(str);
//             return;
//         }

//         _str = new char[strlen(str) + 1];
//         strcpy(_str, str);
//     }

//     void swap(string& s)
//     {
//         std::swap(_str, s._str);
//     }

//     string(const string& s)
//     {
//         string tmp(*this);
//         swap(tmp);
//     }

//     string& operator=(string s)
//     {
//         swap(s);
//         return *this;
//     }

//     ~string()
//     {
//         if(_str)
//         {
//             delete[] _str;
//             _str = nullptr;
//         }
//     }
// };


// class string
// {
// private:
//     char* _str;

// public:
//     string(const char* str = "")
//     {
//         if(nullptr == str)
//         {
//             assert(str);
//             return;
//         }

//         _str = new char[strlen(str) + 1];
//         strcpy(_str, str);
//     }

//     void swap(string& s)
//     {
//         std::swap(_str, s._str);
//     }

//     string(const string& s)
//         : _str(nullptr) // 需要初始化，否则是随机值
//     {
//         string tmp(s._str);
//         swap(tmp);
//     }

//     string& operator=(string s)
//     {
//         swap(s);
//         return *this;
//     }

//     ~string()
//     {
//         if(_str)
//         {
//             delete _str;
//             _str = nullptr;
//         }
//     }
// };


// class string
// {
// private:
//     char* _str; 

// public:
//     string(const char* str = "")
//     {
//         if(nullptr == str)
//         {
//             assert(str);
//             str = nullptr;
//         }

//         _str = new char[strlen(str) + 1];
//         strcpy(_str, str);
//     }

//     void swap(string& s)
//     {
//         std::swap(_str, s._str);
//     }

//     string(const string& s)
//         : _str(nullptr)
//     {
//         string tmp(s._str);
//         swap(tmp);
//     }

//     string& operator=(string s)
//     {
//         swap(s);
//         return *this;
//     }

//     ~string()
//     {
//         if(_str)
//         {
//             delete[] _str;
//             _str = nullptr;
//         }
//     }
// };


// class string
// {
// private:
//     char* _str;

// public:
//     string(const char* str = "")
//     {
//         if(str == nullptr)
//         {
//             assert(str);
//             return;
//         }

//         _str = new char[strlen(str) + 1];
//         strcpy(_str, str);
//     }

//     void swap(string& s)
//     {
//         std::swap(_str, s._str);
//     }

//     string(const string& s)
//         : _str(nullptr)
//     {
//         string tmp(s._str);
//         swap(tmp);
//     }

//     string& operator=(string s)
//     {
//         swap(s);
//         return *this;
//     }

//     ~string()
//     {
//         if(_str)
//         {
//             delete[] _str;
//             _str = nullptr;
//         }
//     }
// };


// class string
// {
// public:
//     string(const char* str = "")
//     {
//         if(str == nullptr)
//         {
//             assert(false);
//             return;
//         }

//         _str = new char[strlen(str) + 1];
//         strcpy(_str, str);
//     }

//     void swap(string& s)
//     {
//         std::swap(_str, s._str);
//     }

//     string(const string& s)
//         : _str(nullptr)
//     {
//         string tmp(s._str);
//         swap(tmp);
//     }

//     string& operator=(string s)
//     {
//         swap(s);
//         return *this;
//     }

//     ~string()
//     {
//         if(_str)
//         {
//             delete[] _str;
//             _str = nullptr;
//         }
//     }

// private:
//     char* _str;
// };



// class string
// {
// public:
//     string(const char* str = "")
//     {
//         if(nullptr == str)
//         {
//             assert(str);
//             return;
//         }

//         _str = new char[strlen(str) + 1];
//         strcpy(_str, str);
//     }

//     string(const string& s)
//         : _str(nullptr)
//     {
//         string tmp(s._str);
//         swap(tmp);
//     }

//     string& operator=(string s)
//     {
//         swap(s);

//         return *this;
//     }

//     ~string()
//     {
//         id(_str)
//         {
//             delete[] _str;
//             _str = nullptr;
//         }
//     }

// private:
//     char* _str;
// }



// class string
// {
// public:
//     string(const char* str = "")
//     {
//         if(nullptr == str)
//         {
//             assert(str);
//             return;
//         }

//         _str = new char[strlen(str) + 1];
//         strcpy(_str, str);
//     }

//     string(const string& s)
//         : _str(nullptr)
//     {
//         string tmp(s._str);
//         std::swap(_str, s._str);
//     }

//     string& operator=(string s)
//     {
//         std::swap(_str, s._str);
//         return *this;
//     }

//     ~string()
//     {
//         if(_str)
//         {
//             delete[] _str;
//             _str = nullptr;
//         }
//     }

// private:
//     char* _str;
// };


class string
{
public:
    string(const char* str = "")
    {
        if(nullptr == str)
        {
            assert(false);
            return;
        }

        _str = new char[strlen(str) + 1];
        strcpy(_str, str);
    }

    ~string()
    {
        if(_str)
        {
            delete[] _str;
            _str = nullptr;
        }
    }

    void swap(string& s)
    {
        std::swap(_str, s._str);
    }

    string(const string& s)
        : _str(s._str)
    {
        string tmp(s._str);
        swap(tmp);
    }

    string& operator=(string s)
    {
        swap(s);

        return *this;
    }

    string& operator=(const string& s)
    {
        if(this != &s)
        {
            char* tmp = new char[strlen(s._str) + 1];
            strcpy(tmp, s._str);
            delete[] _str;
            _str = tmp;
        }

        return *this;
    }

private:
    char* _str;
};




